// 补零
 function buling(n){
        return n>=10 ? ""+n : "0"+n;
    }
	
	
// 日期的格式化
function createDate(){
        // 1.获取日期
        var d = new Date();
        // 2.获取每一部分
        var y = d.getFullYear();
        var m = d.getMonth() + 1;       // 月份直接处理了
        var qf_date = d.getDate();
        var qf_day = d.getDay();
        var h = d.getHours();
        var mts = d.getMinutes();
        var s = d.getSeconds();
        // 3.处理一些数据：周
        switch(qf_day){
            case 0:qf_day = "星期日";break;
            case 1:qf_day = "星期一";break;
            case 2:qf_day = "星期二";break;
            case 3:qf_day = "星期三";break;
            case 4:qf_day = "星期四";break;
            case 5:qf_day = "星期五";break;
            case 6:qf_day = "星期六";break;
        }
        // 4.拼接
        var str = y+"年"+buling(m)+"月"+buling(qf_date)+"日 "+qf_day+" "+buling(h)+":"+buling(mts)+":"+buling(s);
        return str;
    }
    
	
// 计算两个日期之间的差值
function dateDiff(date1,date2){
        var d1 = new Date(date1);
        // if(date2){
        //     // 设置指定日期
        //     var d2 = new Date(date2);
        // }else{
        //     // 获取当前日期
        //     var d2 = new Date();
        // }
        var d2 = date2 ? new Date(date2) : new Date();
        // 如何计算差值？
            // 不安全的做法：两个日期对象可以直接相减
            // console.log(d1 - d2);
            // 最安全的做法是，获取时间戳，然后相减
            var t1 = d1.getTime();
            var t2 = d2.getTime();

            var time = Math.abs(t1 - t2);
            // 根据毫秒数，计算天，时，分，秒
            var tian = parseInt(time/1000/60/60/24);
            var shi = parseInt((time - tian*24*60*60*1000)/1000/60/60);
            var fen = parseInt((time - tian*24*60*60*1000 - shi*60*60*1000)/1000/60);
            var miao = parseInt((time - tian*24*60*60*1000 - shi*60*60*1000 - fen*60*1000)/1000);

            // 优化最终数据的拼接结果
            var str="两个日期之间差值是："+tian+"天"+shi+"时"+fen+"分"+miao+"秒";
			return str;
	}		
      
			
// 获取样式
 function getStyle(ele,attr){
        if(ele.currentStyle){
            var s = ele.currentStyle;
        }else{
            var s = getComputedStyle(ele,false);
        }
        return s[attr];
    }
	
	
// 范围随机数
 function random(a,b){
        return Math.round(Math.random()*(a-b)+b);
    }
	
	
// 随机颜色值
function createColor(){
			// 先生成随机的库：在库内，每种类型的个数都是一致的，保证将来的公平
			var str="";
			for(var i=0;i<6;i++){
				var num=random(0,9);
				var zm=String.fromCharCode(random(97,102));
				str=str+num+zm;
			}
			// console.log(str);
			// 再从随机生成的库中，随机取六个索引，拼接
			var colorNum="#";
			for(var i=0;i<6;i++){
				var index=random(0,str.length-1);
				colorNum+=str[index];
			}
			return colorNum;
		}
		
		
		
// 数组去重
 function norepeat(bArr){
        // 需要有一个判断是否存在的功能：has
        var sArr = [];
        for(var i=0;i<bArr.length;i++){
            // 利用自己封装的判断数组中是否存在某个数据的功能
            // 判断sArr中，是否具有bArr[i]这个数据
            // 存在true，不存在false
            var qwe = has(sArr, bArr[i]);
            // 要的是不存在，要的是false，但是false放在if中就不执行了，所以要 非 一下
            if(!qwe){
                sArr.push(bArr[i]);
            }
        }
        return sArr;
    }
	
 // 判断数组中是否存在某个数据，存在true，不存在false
 function has(myarr,data){
        for(var i=0;i<myarr.length;i++){
            // 因为这里是循环，循环会执行多次，每次只判断一个
            if(myarr[i] === data){
                // 如果数据相同了，可以返回true，同时函数停止
                return true;
            }
        }
        return false;
    }	 
	
// 事件冒泡的阻止，是有兼容的
function stopBubble(e){
        if(e.stopPropagation){
            e.stopPropagation(); // 方法兼容正常浏览器
        }else{
            e.cancelBubble = true;// 属性兼容IE浏览器

        }
    }
	

// 添加事件监听的兼容方法
 function addEvent(ele,type,cb){
            if(ele.addEventListener){
                ele.addEventListener(type,cb,false);
            }else{
                ele.attachEvent("on"+type,cb);
            }
        }


// 删除事件监听的兼容方法
function removeEvent(ele,type,cb){
        if(ele.removeEventListener){
             ele.removeEventListener(type,cb,false);
        }else{
             ele.detachEvent("on"+type,cb);
        }
    }

 // 事件委托的封装
 function eveEnt(child,cb){
		return function(eve){
			   let e=eve || window.event;
			   let muBiaoEle=e.target || e.srcElement;
			   for(let i=0;i<child.length;i++){
				   if(child[i]==muBiaoEle){
					   // cb.bind(muBiaoEle)();
					   // cb.call(muBiaoEle);
					   cb.apply(muBiaoEle);
				   }
			   }
		}
    }

// 运动与透明度的封装
function move(ele,attr,target){
        clearInterval(ele.t);
        ele.t = setInterval(() => {
            // 透明度的单独处理：透明度的属性值是一个数值，没有px，而且是从0-1
            // 结果不用取整，并且为了统一将来的步长计算，先*100
            if(attr == "opacity"){
                var iNow = getStyle(ele,attr) * 100;
            }else{
                var iNow = parseInt(getStyle(ele,attr));
            }

            let speed = (target - iNow)/10;
            speed = speed < 0 ? Math.floor(speed) : Math.ceil(speed);
            if(iNow === target){
                clearInterval(ele.t);
            }else{
                // 透明度的单独设置：因为获取的时候为了统一将来的步长计算，*100了
                // 这里设置时要再，/100
                if(attr == "opacity"){
                    ele.style.opacity = (iNow + speed)/100;
                }else{
                    ele.style[attr] = iNow + speed + "px";
                }
            }
        }, 30);
    }
// move(obox2,"left",1000);
// move(obox1,"opacity",20);
	
// 运动2.0升级的封装	
function move2(ele,obj,cb){
		clearInterval(ele.obj);
		ele.t = setInterval(() => {
		  var i=true;
		  for(var attr in obj){
			  // 透明度的单独处理：透明度的属性值是一个数值，没有px，而且是从0-1
			      // 结果不用取整，并且为了统一将来的步长计算，先*100
			 if(attr == "opacity"){
			     var iNow = getStyle(ele,attr) * 100;
			 }else{
			     var iNow = parseInt(getStyle(ele,attr));
			 }
			 			  
			 let speed = (obj[attr] - iNow)/10;
			 speed = speed < 0 ? Math.floor(speed) : Math.ceil(speed);
			 if(iNow !== obj[attr]){
			     i=false;
			 }
			     // 透明度的单独设置：因为获取的时候为了统一将来的步长计算，*100了
			     // 这里设置时要再，/100
			 if(attr == "opacity"){
			     ele.style.opacity = (iNow + speed)/100;
			 }else{
			     ele.style[attr] = iNow + speed + "px";
			 }        
		  }
		  if(i){
			 clearInterval(ele.t);
			 if(cb){
				 cb();
			 }
		  }
		}, 30);
	}
	// move2(obox3,{left:500,top:53,},function(){alert("结束了");});
	
// 数值数组中寻找最小数值
function getMin(arr){
		var myarr=[];
		for(var j=0;j<arr.length;j++){
			myarr.push(arr[j]);
		}
		return myarr.sort((a,b)=>a-b)[0];
	} 
	
// 数值数组中寻找最大数值
function getMax(arr){
		var myarr=[];
		for(var j=0;j<arr.length;j++){
			myarr.push(arr[j]);
		}
		return myarr.sort((a,b)=>b-a)[0];
	} 

// AJAX会话技术封装
function ajax(ops){
		 // 先处理默认属性
		ops.type=ops.type || "get";
		ops.data=ops.data || "";
		// 根据当前的请求方式，决定是否需要拼接数据，处理url
		// ops.url=ops.type=="get" ? ops.url+"?"+ops.data : ops.url;
		if(ops.type=="get"){
			let t=new Date().getTime();
			ops.url=ops.url+"?_xmt="+t+"&"+ops.data;
		}
		// 创建xhr对象
		var xhr=new XMLHttpRequest();
		// 开启请求
		xhr.open(ops.type,ops.url);
		// 根据类型决定send的内容及内容数据格式
		if(ops.type=="get"){
			xhr.send();
		}else{
			xhr.setRequestHeader("Content-type","application/x-www-form-urlencoded");
			xhr.send(ops.data);
		}
		// 开始监听
		xhr.onreadystatechange=function(){
			if(xhr.readyState==4 && xhr.status==200){
				// 执行回调函数，取出数据
				ops.success(xhr.responseText);
			}
		}
	}
// document.onclick=function(){
// 		var url="http://127.0.0.1/day23/data/data.php";
// 		ajax({
// 			success:function(res){
// 				console.log(res);
// 			},
// 			url:url,
// 			type:"get",
// 			data:"user=admin&pass=12345"
// 		});
// 	}

// JSONP的封装
function jsonp(url,success,data){
    data = data || {};
    let str = "";
    for(var key in data){
        str += `${key}=${data[key]}&`;
    }
    let t = new Date().getTime();
    str = str + "_xmt="+t;
    var script = document.createElement("script");
    script.src = url + "?" + str;
    document.body.appendChild(script);
    
    window[data[data.fieldName]] = function(res){
        success(res);
    }
}
// document.onclick=function(){
// 		let url="http://127.0.0.1/day24/jsonp/data/jsonp4.php";
// 		jsonp(url,function(res){
// 			console.log(res);
// 		},{
// 			user:"root",
// 			pass:0987,
// 			// 根据后台规定的字段名，随便传个函数名过去，让后台返回值后，能被script解析
// 			cbn:"asd",
// 			 // 为了实现前端的封装思想，为了适应后台不断变化的地址，将后台要接受的字段名，传给自己的函数
// 			fieldName:"cbn"
// 		});
// 	}

// ajax-promise封装的方法
function ajax_promise(ops){
    ops.type = ops.type || "get";
    ops.data = ops.data || {};
    var str = "";
    for(var key in ops.data){
        str += `${key}=${ops.data[key]}&`;
    }
    if(ops.type=="get"){
        let t = new Date().getTime();
        ops.url = ops.url + "?" + str + "_xmt="+ t;
    }
    var xhr = new XMLHttpRequest();
    xhr.open(ops.type, ops.url);
    if(ops.type == "get"){
        xhr.send();
    }else{
        xhr.setRequestHeader("Content-type","application/x-www-form-urlencoded");
        xhr.send(ops.data);
    }
    return new Promise(function(resolve,reject){
        xhr.onreadystatechange = function(){
            if(xhr.readyState === 4 && xhr.status === 200){
                resolve(xhr.responseText);
            }else if(xhr.readyState === 4 && xhr.status !== 200){
                reject("当前请求失败了，失败的原因是：" + xhr.status);
            }
        }
    })
}
// 当前ajax_promise封装完成之后的调用方式：
// var p1 = ajax_promise({
//     type:"get",
//     url:"",
//     data:{
//         user:"admin",
//         pass:123
//     }
// })
// p1.then(function(res){
//     console.log(res)
// })
// p1.catch(function(res){
//     console.log(res)
// })


// ajax函数自身执行的时候不再接收成功和失败的处理函数了
// 交给ajax内部封装的promise处理

// 懒加载功能
function lazyImg(elems){
		let arrImg=Array.from(elems);
		let scrollT=document.documentElement.scrollTop;
		for(let i=0;i<arrImg.length;i++){
			if(arrImg[i].offsetTop-100<clientH+scrollT){
				arrImg[i].src=arrImg[i].getAttribute("lazy");
				// 如果图片已经加载好了，那么就将这个元素，从数组中剔除掉
				arrImg.splice(i,1);
				// 因为在数组的遍历中，改变了数组的长度，为了能继续正常拿到数组的其他数据，要根据情况实际修改i的值
				i--;
			}
		}
	}
// 懒加载函数调用方法（首先要将页面上的所有img src替换成img lazy）
// let imgs=document.querySelectorAll("img");
// 	let clientH=document.documentElement.clientHeight;
// 	lazyImg(imgs);
// 	window.onscroll=function(){
// 		lazyImg(imgs);
// 	}